
import { suitPriority, specialWeights, pointWeights, getRankValue } from './cardComparison';
// 牌型验证函数
//返回牌型的英文
export function validateCardType(cards) {
    if (!cards || cards.length === 0) return false;
    console.log("测试"+cards.length)
  
    // 特殊牌型判断
    if (cards.length === 2) {
      const [c1, c2] = cards.map(c => c.rank);
      if (c1 === "joker" && c2 === "Joker") return 'rocket'; // 王炸
    }
  
    // 统计牌型分布
    const rankCount = {};
    cards.forEach(card => {
      rankCount[card.rank] = (rankCount[card.rank] || 0) + 1;
    });
    
    // 牌型分布排序（降序）
    const counts = Object.values(rankCount).sort((a, b) => b - a);
    console.log(counts+"长度")
    // 获取排序后的牌值（排除大小王）
    const sortedRanks = Object.keys(rankCount)
      .map(rank => getRankValue(rank))
      .filter(r => r < 16)
      .sort((a, b) => a - b);
      console.log("排序")
    console.log(sortedRanks)
    // 基础牌型判断
    if (counts[0] === 4&&cards.length===4){ return 'bomb'; }
    else if (counts[0] === 4 && counts[1] === 1 && counts[2] === 1 && cards.length === 6) {
      return 'fourWithTwo'; // 炸弹带两张

    }if(counts[0]===4&&counts[1]===2&&counts[2]===2&&cards.length===8){
      return 'fourWithTwoPairs'; // 炸弹带两对
    }// 炸弹
    
    // 顺子相关判断
    const isStraight = () => {
      if (sortedRanks.length < 5) return false;
      
      // 检查是否包含2或大小王
      if (sortedRanks.includes(15)) return false; // 2
      if (sortedRanks.some(r => r > 14)) return false; // 大小王
      
      // 检查连续性
      const min = sortedRanks[0];
      const max = sortedRanks[sortedRanks.length - 1];
      return (max - min + 1) === sortedRanks.length;
    };
    
    if (isStraight()) return 'straight'; // 顺子
  
    //判断是否连续，通过前一个减后一个是否为1，判断是否是连对
    const isConsecutive =(ranks)=>{
      for (let i = 0; i < ranks.length - 1; i++) {
        if (ranks[i + 1] - ranks[i] !== 1) {
          return false;
        }
      }
      return true;
    }
    // 对子相关判断
    if (counts[0] === 2) {
      if (cards.length === 2) return 'pair'; // 对子
      if (counts.every(c => c === 2) && cards.length % 2 === 0) {
        // 获取所有对子点数，排除2(15)和大小王(＞15)
          const pairRanks = Object.keys(rankCount)
          .map(rank => getRankValue(rank)) // 转为数值
          .filter(val => val < 15) // 只保留3-A的点数
          .sort((a, b) => a - b); // 升序排序
        
        // 检查连续性和最小对数要求
        if (pairRanks.length >= 3 && isConsecutive(pairRanks)) {
          return 'doubleStraight'; // 连对
        }
      }
    }
  
    // 三带相关判断
    if (counts[0] === 3) {
      if (cards.length === 4) return 'threeWithSingle'; // 三带一
      if (cards.length === 5 && counts.slice(1)[0] === 2) 
        return 'threeWithPair'; // 三带二
      // if (cards.length >= 6 && counts.slice(1).every(c => c === 1))
      //   return 'airplane'; // 飞机
      if(cards.length>=6&&counts.slice(1)[0]==3){
         // 获取所有对子点数，排除2(15)和大小王(＞15)
         const pairRanks = Object.keys(rankCount)
         .map(rank => getRankValue(rank)) // 转为数值
         .filter(val => val < 15) // 只保留3-A的点数
         .sort((a, b) => a - b); // 升序排序
        // 检查连续性和最小对数要求
        if (pairRanks.length >= 2 && isConsecutive(pairRanks)) {
          return 'airplane'; // 飞机
        }
      }

    }
  
    // 其他基础牌型
    if (cards.length === 1) return 'single'; // 单张
    if (counts[0] === 3 && cards.length === 3) return 'triple'; // 三张
  
    return false;
  }
  //牌的排序
  export function sortCards(cards) {
    return [...cards].sort((a, b) => {
      // 处理特殊牌型
      const aSpecial = specialWeights[a.rank];
      const bSpecial = specialWeights[b.rank];
      if (aSpecial || bSpecial) {
        return (bSpecial || 0) - (aSpecial || 0);
      }
  
      // 处理常规牌型
      const aPoint = pointWeights[a.rank] || 0;
      const bPoint = pointWeights[b.rank] || 0;
  
      if (aPoint !== bPoint) {
        return bPoint - aPoint;
      }
  
      // 处理同点数花色排序
      return suitPriority[b.suit.log] - suitPriority[a.suit.log];
    });
  }